module klang.ir.常量值.IR常量值_;
import 全局;
import klang.编译.核心.核心_: 整数_, 创建数组, 词典_, 创建词典从关联数组, 简单链表_;
import klang.编译.类型.类型_: 符号表_;
import klang.ir.类型.IR类型_: ISK;
import klang.编译.类型.枚举值.枚举值_: SK;
import klang.编译.工具.工具_: 创建符号表;
ISK[dstring] _标点表;
ISK[dstring] _关键字表;
ISK[dstring] _中文关键字表_;
ISK[dstring] _IR令牌文本表;
ISK[dstring] _IR中文令牌文本表;
dstring[] 组合令牌文本;
简单链表_[dchar] 组合令牌关联数组;
ISK[dstring] _中英文关键字表;
词典_!(ISK) 关键字词典;
词典_!(ISK) 标点令牌表;
dstring[] 关键字文本数组;
dstring[] 中文关键字文本数字;
static this() {
    _标点表 = [
        "{"d : ISK.左大括号,
        "}"d : ISK.右大括号,
        "("d : ISK.左括号,
        ")"d : ISK.右括号,
        "["d : ISK.左方括号,
        "]"d : ISK.右方括号,
        "\""d : ISK.双引号,
        "'"d : ISK.单引号,
        "."d : ISK.点号,
        ";"d : ISK.分号,
        ","d : ISK.逗号,
        "<"d : ISK.左尖括号,
        ">"d : ISK.右尖括号,
        "+"d : ISK.加号,
        "-"d : ISK.减号,
        "*"d : ISK.星号,
        "\\"d : ISK.反斜杠,
        "/"d : ISK.除号,
        "%"d : ISK.百分号,
        "&"d : ISK.且号,
        "|"d : ISK.或号,
        "^"d : ISK.异或号,
        "!"d : ISK.叹号,
        "~"d : ISK.波折号,
        "$"d : ISK.美元,
        "?"d : ISK.问号,
        ":"d : ISK.冒号,
        "@"d : ISK.艾特,
        "#"d : ISK.井号,
        "`"d : ISK.反引号,
        "="d : ISK.等号,
        "..."d : ISK.三点号
    ];
    _关键字表 = [
        "vscale"d : ISK.vscale,
        "true"d : ISK.true_,
        "false"d : ISK.false_,
        "declare"d : ISK.declare,
        "define"d : ISK.define,
        "global"d : ISK.global,
        "constant"d : ISK.constant,
        "dso_local"d : ISK.dso_local,
        "dso_preemptable"d : ISK.dso_preemptable,
        "private"d : ISK.private_,
        "internal"d : ISK.internal,
        "linkonce"d : ISK.linkonce,
        "linkonce_odr"d : ISK.linkonce_odr,
        "weak"d : ISK.weak,
        "weak_odr"d : ISK.weak_odr,
        "appending"d : ISK.appending,
        "dllimport"d : ISK.dllimport,
        "dllexport"d : ISK.dllexport,
        "common"d : ISK.common,
        "available_externally"d : ISK.available_externally,
        "default"d : ISK.default_,
        "hidden"d : ISK.hidden,
        "protected"d : ISK.protected_,
        "unnamed_addr"d : ISK.unnamed_addr,
        "local_unnamed_addr"d : ISK.local_unnamed_addr,
        "externally_initialized"d : ISK.externally_initialized,
        "extern_weak"d : ISK.extern_weak,
        "external"d : ISK.external,
        "thread_local"d : ISK.thread_local,
        "localdynamic"d : ISK.localdynamic,
        "initialexec"d : ISK.initialexec,
        "localexec"d : ISK.localexec,
        "zeroinitializer"d : ISK.zeroinitializer,
        "undef"d : ISK.undef,
        "poison"d : ISK.poison,
        "null"d : ISK.null_,
        "none"d : ISK.none,
        "to"d : ISK.to,
        "caller"d : ISK.caller,
        "within"d : ISK.within,
        "from"d : ISK.from,
        "tail"d : ISK.tail,
        "musttail"d : ISK.musttail,
        "notail"d : ISK.notail,
        "target"d : ISK.target,
        "triple"d : ISK.triple,
        "source_filename"d : ISK.source_filename,
        "unwind"d : ISK.unwind,
        "datalayout"d : ISK.datalayout,
        "volatile"d : ISK.volatile,
        "atomic"d : ISK.atomic,
        "unordered"d : ISK.unordered,
        "monotonic"d : ISK.monotonic,
        "acquire"d : ISK.acquire,
        "release"d : ISK.release,
        "acq_rel"d : ISK.acq_rel,
        "seq_cst"d : ISK.seq_cst,
        "syncscope"d : ISK.syncscope,
        "nnan"d : ISK.nnan,
        "ninf"d : ISK.ninf,
        "nsz"d : ISK.nsz,
        "arcp"d : ISK.arcp,
        "contract"d : ISK.contract,
        "reassoc"d : ISK.reassoc,
        "afn"d : ISK.afn,
        "fast"d : ISK.fast,
        "nuw"d : ISK.nuw,
        "nsw"d : ISK.nsw,
        "exact"d : ISK.exact,
        "inbounds"d : ISK.inbounds,
        "inrange"d : ISK.inrange,
        "align"d : ISK.align_,
        "addrspace"d : ISK.addrspace,
        "section"d : ISK.section,
        "partition"d : ISK.partition,
        "alias"d : ISK.alias_,
        "ifunc"d : ISK.ifunc,
        "module"d : ISK.module_,
        "asm"d : ISK.asm_,
        "sideeffect"d : ISK.sideeffect,
        "alignstack"d : ISK.alignstack,
        "inteldialect"d : ISK.inteldialect,
        "gc"d : ISK.gc,
        "prefix"d : ISK.prefix,
        "prologue"d : ISK.prologue,
        "c"d : ISK.c,
        "cc"d : ISK.cc,
        "ccc"d : ISK.ccc,
        "fastcc"d : ISK.fastcc,
        "coldcc"d : ISK.coldcc,
        "intel_ocl_bicc"d : ISK.intel_ocl_bicc,
        "cfguard_checkcc"d : ISK.cfguard_checkcc,
        "x86_stdcallcc"d : ISK.x86_stdcallcc,
        "x86_fastcallcc"d : ISK.x86_fastcallcc,
        "x86_thiscallcc"d : ISK.x86_thiscallcc,
        "x86_vectorcallcc"d : ISK.x86_vectorcallcc,
        "x86_regcallcc"d : ISK.x86_regcallcc,
        "arm_apcscc"d : ISK.arm_apcscc,
        "arm_aapcscc"d : ISK.arm_aapcscc,
        "arm_aapcs_vfpcc"d : ISK.arm_aapcs_vfpcc,
        "aarch64_vector_pcs"d : ISK.aarch64_vector_pcs,
        "aarch64_sve_vector_pcs"d : ISK.aarch64_sve_vector_pcs,
        "msp430_intrcc"d : ISK.msp430_intrcc,
        "avr_intrcc"d : ISK.avr_intrcc,
        "avr_signalcc"d : ISK.avr_signalcc,
        "ptx_kernel"d : ISK.ptx_kernel,
        "ptx_device"d : ISK.ptx_device,
        "spir_kernel"d : ISK.spir_kernel,
        "spir_func"d : ISK.spir_func,
        "x86_64_sysvcc"d : ISK.x86_64_sysvcc,
        "win64cc"d : ISK.win64cc,
        "webkit_jscc"d : ISK.webkit_jscc,
        "anyregcc"d : ISK.anyregcc,
        "swiftcc"d : ISK.swiftcc,
        "swifttailcc"d : ISK.swifttailcc,
        "preserve_mostcc"d : ISK.preserve_mostcc,
        "preserve_allcc"d : ISK.preserve_allcc,
        "ghccc"d : ISK.ghccc,
        "x86_intrcc"d : ISK.x86_intrcc,
        "hhvmcc"d : ISK.hhvmcc,
        "hhvm_ccc"d : ISK.hhvm_ccc,
        "cxx_fast_tlscc"d : ISK.cxx_fast_tlscc,
        "amdgpu_vs"d : ISK.amdgpu_vs,
        "amdgpu_ls"d : ISK.amdgpu_ls,
        "amdgpu_hs"d : ISK.amdgpu_hs,
        "amdgpu_es"d : ISK.amdgpu_es,
        "amdgpu_gs"d : ISK.amdgpu_gs,
        "amdgpu_ps"d : ISK.amdgpu_ps,
        "amdgpu_cs"d : ISK.amdgpu_cs,
        "amdgpu_kernel"d : ISK.amdgpu_kernel,
        "amdgpu_gfx"d : ISK.amdgpu_gfx,
        "tailcc"d : ISK.tailcc,
        "attributes"d : ISK.attributes,
        "allocsize"d : ISK.allocsize,
        "alwaysinline"d : ISK.alwaysinline,
        "argmemonly"d : ISK.argmemonly,
        "sanitize_address"d : ISK.sanitize_address,
        "sanitize_hwaddress"d : ISK.sanitize_hwaddress,
        "sanitize_memtag"d : ISK.sanitize_memtag,
        "builtin"d : ISK.builtin,
        "byval"d : ISK.byval,
        "inalloca"d : ISK.inalloca,
        "cold"d : ISK.cold,
        "convergent"d : ISK.convergent,
        "dereferenceable"d : ISK.dereferenceable,
        "dereferenceable_or_null"d : ISK.dereferenceable_or_null,
        "inaccessiblememonly"d : ISK.inaccessiblememonly,
        "inaccessiblemem_or_argmemonly"d : ISK.inaccessiblemem_or_argmemonly,
        "inlinehint"d : ISK.inlinehint,
        "inreg"d : ISK.inreg,
        "jumptable"d : ISK.jumptable,
        "minsize"d : ISK.minsize,
        "naked"d : ISK.naked,
        "nest"d : ISK.nest,
        "noalias"d : ISK.noalias,
        "noundef"d : ISK.noundef,
        "nobuiltin"d : ISK.nobuiltin,
        "nocallback"d : ISK.nocallback,
        "nocapture"d : ISK.nocapture,
        "noduplicate"d : ISK.noduplicate,
        "nofree"d : ISK.nofree,
        "noimplicitfloat"d : ISK.noimplicitfloat,
        "noinline"d : ISK.noinline,
        "norecurse"d : ISK.norecurse,
        "nonlazybind"d : ISK.nonlazybind,
        "nomerge"d : ISK.nomerge,
        "nonnull"d : ISK.nonnull,
        "noprofile"d : ISK.noprofile,
        "noredzone"d : ISK.noredzone,
        "noreturn"d : ISK.noreturn,
        "nosync"d : ISK.nosync,
        "nocf_check"d : ISK.nocf_check,
        "nounwind"d : ISK.nounwind,
        "nosanitize_coverage"d : ISK.nosanitize_coverage,
        "null_pointer_is_valid"d : ISK.null_pointer_is_valid,
        "optforfuzzing"d : ISK.optforfuzzing,
        "optnone"d : ISK.optnone,
        "optsize"d : ISK.optsize,
        "preallocated"d : ISK.preallocated,
        "readnone"d : ISK.readnone,
        "readonly"d : ISK.readonly,
        "returned"d : ISK.returned,
        "returns_twice"d : ISK.returns_twice,
        "signext"d : ISK.signext,
        "speculatable"d : ISK.speculatable,
        "ssp"d : ISK.ssp,
        "sspreq"d : ISK.sspreq,
        "sspstrong"d : ISK.sspstrong,
        "safestack"d : ISK.safestack,
        "shadowcallstack"d : ISK.shadowcallstack,
        "sret"d : ISK.sret,
        "sanitize_thread"d : ISK.sanitize_thread,
        "sanitize_memory"d : ISK.sanitize_memory,
        "speculative_load_hardening"d : ISK.speculative_load_hardening,
        "strictfp"d : ISK.strictfp,
        "swifterror"d : ISK.swifterror,
        "swiftself"d : ISK.swiftself,
        "swiftasync"d : ISK.swiftasync,
        "uwtable"d : ISK.uwtable,
        "vscale_range"d : ISK.vscale_range,
        "willreturn"d : ISK.willreturn,
        "writeonly"d : ISK.writeonly,
        "zeroext"d : ISK.zeroext,
        "immarg"d : ISK.immarg,
        "byref"d : ISK.byref,
        "mustprogress"d : ISK.mustprogress,
        "type"d : ISK.type,
        "opaque"d : ISK.opaque,
        "comdat"d : ISK.comdat,
        "any"d : ISK.any,
        "exactmatch"d : ISK.exactmatch,
        "largest"d : ISK.largest,
        "noduplicates"d : ISK.noduplicates,
        "samesize"d : ISK.samesize,
        "eq"d : ISK.eq,
        "ne"d : ISK.ne,
        "slt"d : ISK.slt,
        "sgt"d : ISK.sgt,
        "sle"d : ISK.sle,
        "sge"d : ISK.sge,
        "ult"d : ISK.ult,
        "ugt"d : ISK.ugt,
        "ule"d : ISK.ule,
        "uge"d : ISK.uge,
        "oeq"d : ISK.oeq,
        "one"d : ISK.one,
        "olt"d : ISK.olt,
        "ogt"d : ISK.ogt,
        "ole"d : ISK.ole,
        "oge"d : ISK.oge,
        "ord"d : ISK.ord,
        "uno"d : ISK.uno,
        "ueq"d : ISK.ueq,
        "une"d : ISK.une,
        "xchg"d : ISK.xchg,
        "nand"d : ISK.nand,
        "max"d : ISK.max,
        "min"d : ISK.min,
        "umax"d : ISK.umax,
        "umin"d : ISK.umin,
        "fneg"d : ISK.fneg,
        "add"d : ISK.add,
        "fadd"d : ISK.fadd,
        "sub"d : ISK.sub,
        "fsub"d : ISK.fsub,
        "mul"d : ISK.mul,
        "fmul"d : ISK.fmul,
        "udiv"d : ISK.udiv,
        "sdiv"d : ISK.sdiv,
        "fdiv"d : ISK.fdiv,
        "urem"d : ISK.urem,
        "srem"d : ISK.srem,
        "frem"d : ISK.frem,
        "shl"d : ISK.shl,
        "lshr"d : ISK.lshr,
        "ashr"d : ISK.ashr,
        "and"d : ISK.and,
        "or"d : ISK.or,
        "xor"d : ISK.xor,
        "icmp"d : ISK.icmp,
        "fcmp"d : ISK.fcmp,
        "phi"d : ISK.phi,
        "call"d : ISK.call,
        "trunc"d : ISK.trunc,
        "zext"d : ISK.zext,
        "sext"d : ISK.sext,
        "fptrunc"d : ISK.fptrunc,
        "fpext"d : ISK.fpext,
        "uitofp"d : ISK.uitofp,
        "sitofp"d : ISK.sitofp,
        "fptoui"d : ISK.fptoui,
        "fptosi"d : ISK.fptosi,
        "inttoptr"d : ISK.inttoptr,
        "ptrtoint"d : ISK.ptrtoint,
        "bitcast"d : ISK.bitcast,
        "addrspacecast"d : ISK.addrspacecast,
        "select"d : ISK.select,
        "va_arg"d : ISK.va_arg,
        "landingpad"d : ISK.landingpad,
        "personality"d : ISK.personality,
        "cleanup"d : ISK.cleanup,
        "catch"d : ISK.catch_,
        "filter"d : ISK.filter,
        "ret"d : ISK.ret,
        "br"d : ISK.br,
        "switch"d : ISK.switch_,
        "indirectbr"d : ISK.indirectbr,
        "invoke"d : ISK.invoke,
        "resume"d : ISK.resume,
        "unreachable"d : ISK.unreachable,
        "cleanupret"d : ISK.cleanupret,
        "catchswitch"d : ISK.catchswitch,
        "catchret"d : ISK.catchret,
        "catchpad"d : ISK.catchpad,
        "cleanuppad"d : ISK.cleanuppad,
        "callbr"d : ISK.callbr,
        "alloca"d : ISK.alloca,
        "load"d : ISK.load,
        "store"d : ISK.store,
        "fence"d : ISK.fence,
        "cmpxchg"d : ISK.cmpxchg,
        "atomicrmw"d : ISK.atomicrmw,
        "getelementptr"d : ISK.getelementptr,
        "extractelement"d : ISK.extractelement,
        "insertelement"d : ISK.insertelement,
        "shufflevector"d : ISK.shufflevector,
        "extractvalue"d : ISK.extractvalue,
        "insertvalue"d : ISK.insertvalue,
        "blockaddress"d : ISK.blockaddress,
        "dso_local_equivalent"d : ISK.dso_local_equivalent,
        "freeze"d : ISK.freeze,
        "distinct"d : ISK.distinct,
        "uselistorder"d : ISK.uselistorder,
        "uselistorder_bb"d : ISK.uselistorder_bb,
        "path"d : ISK.path,
        "hash"d : ISK.hash,
        "gv"d : ISK.gv,
        "guid"d : ISK.guid,
        "name"d : ISK.name,
        "summaries"d : ISK.summaries,
        "flags"d : ISK.flags,
        "blockcount"d : ISK.blockcount,
        "linkage"d : ISK.linkage,
        "visibility"d : ISK.visibility,
        "notEligibleToImport"d : ISK.notEligibleToImport,
        "live"d : ISK.live,
        "dsoLocal"d : ISK.dsoLocal,
        "canAutoHide"d : ISK.canAutoHide,
        "function"d : ISK.function_,
        "insts"d : ISK.insts,
        "funcFlags"d : ISK.funcFlags,
        "readNone"d : ISK.readNone,
        "readOnly"d : ISK.readOnly,
        "noRecurse"d : ISK.noRecurse,
        "returnDoesNotAlias"d : ISK.returnDoesNotAlias,
        "noInline"d : ISK.noInline,
        "alwaysInline"d : ISK.alwaysInline,
        "noUnwind"d : ISK.noUnwind,
        "mayThrow"d : ISK.mayThrow,
        "hasUnknownCall"d : ISK.hasUnknownCall,
        "calls"d : ISK.calls,
        "callee"d : ISK.callee,
        "params"d : ISK.params,
        "param"d : ISK.param,
        "hotness"d : ISK.hotness,
        "unknown"d : ISK.unknown,
        "hot"d : ISK.hot,
        "critical"d : ISK.critical,
        "relbf"d : ISK.relbf,
        "variable"d : ISK.variable,
        "vTableFuncs"d : ISK.vTableFuncs,
        "virtFunc"d : ISK.virtFunc,
        "aliasee"d : ISK.aliasee,
        "refs"d : ISK.refs,
        "typeIdInfo"d : ISK.typeIdInfo,
        "typeTests"d : ISK.typeTests,
        "typeTestAssumeVCalls"d : ISK.typeTestAssumeVCalls,
        "typeCheckedLoadVCalls"d : ISK.typeCheckedLoadVCalls,
        "typeTestAssumeConstVCalls"d : ISK.typeTestAssumeConstVCalls,
        "typeCheckedLoadConstVCalls"d : ISK.typeCheckedLoadConstVCalls,
        "vFuncId"d : ISK.vFuncId,
        "offset"d : ISK.offset,
        "args"d : ISK.args,
        "typeid"d : ISK.typeid_,
        "typeidCompatibleVTable"d : ISK.typeidCompatibleVTable,
        "summary"d : ISK.summary,
        "typeTestRes"d : ISK.typeTestRes,
        "kind"d : ISK.kind,
        "unsat"d : ISK.unsat,
        "byteArray"d : ISK.byteArray,
        "inline"d : ISK.inline,
        "single"d : ISK.single,
        "allOnes"d : ISK.allOnes,
        "sizeM1BitWidth"d : ISK.sizeM1BitWidth,
        "alignLog2"d : ISK.alignLog2,
        "sizeM1"d : ISK.sizeM1,
        "bitMask"d : ISK.bitMask,
        "inlineBits"d : ISK.inlineBits,
        "vcall_visibility"d : ISK.vcall_visibility,
        "wpdResolutions"d : ISK.wpdResolutions,
        "wpdRes"d : ISK.wpdRes,
        "indir"d : ISK.indir,
        "singleImpl"d : ISK.singleImpl,
        "branchFunnel"d : ISK.branchFunnel,
        "singleImplName"d : ISK.singleImplName,
        "resByArg"d : ISK.resByArg,
        "byArg"d : ISK.byArg,
        "uniformRetVal"d : ISK.uniformRetVal,
        "uniqueRetVal"d : ISK.uniqueRetVal,
        "virtualConstProp"d : ISK.virtualConstProp,
        "info"d : ISK.info,
        "byte"d : ISK.byte_,
        "bit"d : ISK.bit,
        "varFlags"d : ISK.varFlags,
        "void"d : ISK.void_,
        "half"d : ISK.half,
        "hf"d : ISK.half,
        "bfloat"d : ISK.bfloat,
        "bf"d : ISK.bfloat,
        "float"d : ISK.float_,
        "f32"d : ISK.float_,
        "double"d : ISK.double_,
        "f64"d : ISK.double_,
        "x86_fp80"d : ISK.x86_fp80,
        "f80"d : ISK.x86_fp80,
        "fp128"d : ISK.fp128,
        "f128"d : ISK.fp128,
        "ppc_fp128"d : ISK.ppc_fp128,
        "pf128"d : ISK.ppc_fp128,
        "label"d : ISK.label,
        "metadata"d : ISK.metadata,
        "x86_mmx"d : ISK.x86_mmx,
        "mmx"d : ISK.x86_mmx,
        "x86_amx"d : ISK.x86_amx,
        "amx"d : ISK.x86_amx,
        "token"d : ISK.token,
        "ptr"d : ISK.ptr,
        "x"d : ISK.x,
        "elementtype"d : ISK.elementtype,
        "disable_sanitizer_instrumentation"d : ISK.disable_sanitizer_instrumentation
    ];
    _中文关键字表_ = [
        // 中文
        "倍数"d : ISK.vscale,
        "真"d : ISK.true_,
        "假"d : ISK.false_,
        "声明"d : ISK.declare,
        "定义"d : ISK.define,
        "全局"d : ISK.global,
        "常量"d : ISK.constant,
        "运行本地"d : ISK.dso_local,
        "运行抢占"d : ISK.dso_preemptable,
        "私有"d : ISK.private_,
        "内部"d : ISK.internal,
        "链接一次"d : ISK.linkonce,
        "链接一次_旧的"d : ISK.linkonce_odr,
        "弱链"d : ISK.weak,
        "弱链旧的"d : ISK.weak_odr,
        "附加的"d : ISK.appending,
        "dll导入"d : ISK.dllimport,
        "dll导出"d : ISK.dllexport,
        "常见的"d : ISK.common,
        "外部可用"d : ISK.available_externally,
        "默认"d : ISK.default_,
        "隐藏"d : ISK.hidden,
        "保护"d : ISK.protected_,
        "未命名地址"d : ISK.unnamed_addr,
        "本地未命名地址"d : ISK.local_unnamed_addr,
        "外部初始化"d : ISK.externally_initialized,
        "外部_弱"d : ISK.extern_weak,
        "外部的"d : ISK.external,
        "本地线程"d : ISK.thread_local,
        "动态加载"d : ISK.localdynamic,
        "初始执行"d : ISK.initialexec,
        "本地执行"d : ISK.localexec,
        "零值初始"d : ISK.zeroinitializer,
        "未定"d : ISK.undef,
        "毒值"d : ISK.poison,
        "空"d : ISK.null_,
        "无"d : ISK.none,
        "到"d : ISK.to,
        "调用者"d : ISK.caller,
        "在内部"d : ISK.within,
        "从"d : ISK.from,
        "尾调"d : ISK.tail,
        "必须尾调"d : ISK.musttail,
        "不尾调"d : ISK.notail,
        "目标"d : ISK.target,
        "平台"d : ISK.triple,
        "源码文件名"d : ISK.source_filename,
        "展开"d : ISK.unwind,
        "数据布局"d : ISK.datalayout,
        "易变的"d : ISK.volatile,
        "原子"d : ISK.atomic,
        "无序的"d : ISK.unordered,
        "不变的"d : ISK.monotonic,
        "获得"d : ISK.acquire,
        "释放"d : ISK.release,
        "获得_释放"d : ISK.acq_rel,
        "顺序一致"d : ISK.seq_cst,
        "同步范围"d : ISK.syncscope,
        "允许非数字"d : ISK.nnan,
        "允许无穷大"d : ISK.ninf,
        "允许无符号零"d : ISK.nsz,
        "允许倒数"d : ISK.arcp,
        "允许小数压缩"d : ISK.contract,
        "允许重装"d : ISK.reassoc,
        "允许近似"d : ISK.afn,
        "快速"d : ISK.fast,
        "不包装无符号"d : ISK.nuw,
        "不包装有符号"d : ISK.nsw,
        "精确的"d : ISK.exact,
        "在界内"d : ISK.inbounds,
        "在范围"d : ISK.inrange,
        "对齐"d : ISK.align_,
        "地址空间"d : ISK.addrspace,
        "段"d : ISK.section,
        "隔板"d : ISK.partition,
        "别名"d : ISK.alias_,
        "函数别名"d : ISK.ifunc,
        "模块"d : ISK.module_,
        "汇编"d : ISK.asm_,
        "副作用"d : ISK.sideeffect,
        "对齐堆栈"d : ISK.alignstack,
        "因特方言"d : ISK.inteldialect,
        "垃圾回收"d : ISK.gc,
        "前缀"d : ISK.prefix,
        "序言"d : ISK.prologue,
        "c"d : ISK.c,
        "约定"d : ISK.cc,
        "c约定"d : ISK.ccc,
        "快速约定"d : ISK.fastcc,
        "冷约定"d : ISK.coldcc,
        "因特尔约定"d : ISK.intel_ocl_bicc,
        "守卫检查约定"d : ISK.cfguard_checkcc,
        "x86_标准约定"d : ISK.x86_stdcallcc,
        "x86_快速约定"d : ISK.x86_fastcallcc,
        "x86_本体约定"d : ISK.x86_thiscallcc,
        "x86_矢量约定"d : ISK.x86_vectorcallcc,
        "x86_寄存器约定"d : ISK.x86_regcallcc,
        "arm_apcs约定"d : ISK.arm_apcscc,
        "arm_aapcs约定"d : ISK.arm_aapcscc,
        "arm_aapcs_vfp约定"d : ISK.arm_aapcs_vfpcc,
        "aarch64_矢量_pcs约定"d : ISK.aarch64_vector_pcs,
        "aarch64_sve_矢量_pcs约定"d : ISK.aarch64_sve_vector_pcs,
        "msp430_intr约定"d : ISK.msp430_intrcc,
        "avr_intr约定"d : ISK.avr_intrcc,
        "avr_信号约定"d : ISK.avr_signalcc,
        "ptx_内核约定"d : ISK.ptx_kernel,
        "ptx_设备约定"d : ISK.ptx_device,
        "spir_内核约定"d : ISK.spir_kernel,
        "spir_函数约定"d : ISK.spir_func,
        "x86_64_系统约定"d : ISK.x86_64_sysvcc,
        "win64约定"d : ISK.win64cc,
        "网络js约定"d : ISK.webkit_jscc,
        "任意约定"d : ISK.anyregcc,
        "雨燕约定"d : ISK.swiftcc,
        "雨燕尾约定"d : ISK.swifttailcc,
        "保存最多约定"d : ISK.preserve_mostcc,
        "保留所有约定"d : ISK.preserve_allcc,
        "ghc约定"d : ISK.ghccc,
        "x86_intr约定"d : ISK.x86_intrcc,
        "hhvm约定"d : ISK.hhvmcc,
        "hhvm_c约定"d : ISK.hhvm_ccc,
        "c加加_快速_tls约定"d : ISK.cxx_fast_tlscc,
        "amd显卡_vs"d : ISK.amdgpu_vs,
        "amd显卡_ls"d : ISK.amdgpu_ls,
        "amd显卡_hs"d : ISK.amdgpu_hs,
        "amd显卡_es"d : ISK.amdgpu_es,
        "amd显卡_gs"d : ISK.amdgpu_gs,
        "amd显卡_ps"d : ISK.amdgpu_ps,
        "amd显卡_cs"d : ISK.amdgpu_cs,
        "amd显卡_内核"d : ISK.amdgpu_kernel,
        "amd显卡_gfx"d : ISK.amdgpu_gfx,
        "尾约定"d : ISK.tailcc,
        "特性"d : ISK.attributes,
        "分配大小"d : ISK.allocsize,
        "总是内联"d : ISK.alwaysinline,
        "仅指针参数指向的内存"d : ISK.argmemonly,
        "清理地址"d : ISK.sanitize_address,
        "清理硬件地址"d : ISK.sanitize_hwaddress,
        "清理内存标签"d : ISK.sanitize_memtag,
        "内置"d : ISK.builtin,
        "传值"d : ISK.byval,
        "在分配"d : ISK.inalloca,
        "冷的"d : ISK.cold,
        "聚合"d : ISK.convergent,
        "不可引用的"d : ISK.dereferenceable,
        "不可引用的或空"d : ISK.dereferenceable_or_null,
        "仅不可访问"d : ISK.inaccessiblememonly,
        "不可访问或仅参数内存"d : ISK.inaccessiblemem_or_argmemonly,
        "内联提示"d : ISK.inlinehint,
        "在寄存器"d : ISK.inreg,
        "跳转表"d : ISK.jumptable,
        "最小大小"d : ISK.minsize,
        "暴露的"d : ISK.naked,
        "嵌套"d : ISK.nest,
        "无别名"d : ISK.noalias,
        "无未定"d : ISK.noundef,
        "无内置"d : ISK.nobuiltin,
        "无回调"d : ISK.nocallback,
        "无捕获"d : ISK.nocapture,
        "无重复项"d : ISK.noduplicate,
        "无释放"d : ISK.nofree,
        "无隐式小数"d : ISK.noimplicitfloat,
        "非内联"d : ISK.noinline,
        "无递归"d : ISK.norecurse,
        "非惰性绑定"d : ISK.nonlazybind,
        "不合并"d : ISK.nomerge,
        "非空"d : ISK.nonnull,
        "无描述"d : ISK.noprofile,
        "无红色区"d : ISK.noredzone,
        "无返回"d : ISK.noreturn,
        "不同步"d : ISK.nosync,
        "不cf检查"d : ISK.nocf_check,
        "不展开"d : ISK.nounwind,
        "无消毒覆盖范围"d : ISK.nosanitize_coverage,
        "空指针有效"d : ISK.null_pointer_is_valid,
        "模糊优化"d : ISK.optforfuzzing,
        "无优化"d : ISK.optnone,
        "优化大小"d : ISK.optsize,
        "预分配"d : ISK.preallocated,
        "不读"d : ISK.readnone,
        "只读"d : ISK.readonly,
        "返回的"d : ISK.returned,
        "返回两次"d : ISK.returns_twice,
        "符号文本"d : ISK.signext,
        "可推测的"d : ISK.speculatable,
        "堆栈保护"d : ISK.ssp,
        "堆栈溢出保护"d : ISK.sspreq,
        "堆栈溢出保护加强"d : ISK.sspstrong,
        "安全堆栈"d : ISK.safestack,
        "影子调用堆栈"d : ISK.shadowcallstack,
        "结构引用"d : ISK.sret,
        "消毒线程"d : ISK.sanitize_thread,
        "消毒内存"d : ISK.sanitize_memory,
        "推测加载强化"d : ISK.speculative_load_hardening,
        "严格函数指针"d : ISK.strictfp,
        "雨燕错误"d : ISK.swifterror,
        "雨燕自我"d : ISK.swiftself,
        "雨燕异步"d : ISK.swiftasync,
        "展开表实体"d : ISK.uwtable,
        "倍数_范围"d : ISK.vscale_range,
        "明确返回"d : ISK.willreturn,
        "只写"d : ISK.writeonly,
        "零文本"d : ISK.zeroext,
        "立即参数"d : ISK.immarg,
        "引用"d : ISK.byref,
        "必须进步"d : ISK.mustprogress,
        "类型"d : ISK.type,
        "封闭"d : ISK.opaque,
        "封装"d : ISK.comdat,
        "任意"d : ISK.any,
        "精确匹配"d : ISK.exactmatch,
        "最大匹配"d : ISK.largest,
        "无重复项组"d : ISK.noduplicates,
        "相同大小"d : ISK.samesize,
        "eq"d : ISK.eq,
        "ne"d : ISK.ne,
        "slt"d : ISK.slt,
        "sgt"d : ISK.sgt,
        "sle"d : ISK.sle,
        "sge"d : ISK.sge,
        "ult"d : ISK.ult,
        "ugt"d : ISK.ugt,
        "ule"d : ISK.ule,
        "uge"d : ISK.uge,
        "oeq"d : ISK.oeq,
        "one"d : ISK.one,
        "olt"d : ISK.olt,
        "ogt"d : ISK.ogt,
        "ole"d : ISK.ole,
        "oge"d : ISK.oge,
        "ord"d : ISK.ord,
        "uno"d : ISK.uno,
        "ueq"d : ISK.ueq,
        "une"d : ISK.une,
        "赋值"d : ISK.xchg,
        "且取反"d : ISK.nand,
        "最大"d : ISK.max,
        "最小"d : ISK.min,
        "无符号最大"d : ISK.umax,
        "无符号最小"d : ISK.umin,
        "取反"d : ISK.fneg,
        "求和"d : ISK.add,
        "小数求和"d : ISK.fadd,
        "求差"d : ISK.sub,
        "小数求差"d : ISK.fsub,
        "求积"d : ISK.mul,
        "小数求积"d : ISK.fmul,
        "无符号求商"d : ISK.udiv,
        "有符号求商"d : ISK.sdiv,
        "小数求商"d : ISK.fdiv,
        "无符号求余"d : ISK.urem,
        "有符号求余"d : ISK.srem,
        "小数求余"d : ISK.frem,
        "左移"d : ISK.shl,
        "逻辑右移"d : ISK.lshr,
        "带符号右移"d : ISK.ashr,
        "且"d : ISK.and,
        "或"d : ISK.or,
        "异或"d : ISK.xor,
        "整数比较"d : ISK.icmp,
        "小数比较"d : ISK.fcmp,
        "PHI节点"d : ISK.phi,
        "调用"d : ISK.call,
        "截断转换"d : ISK.trunc,
        "零扩展转换"d : ISK.zext,
        "符号位扩展转换"d : ISK.sext,
        "小数截断转换"d : ISK.fptrunc,
        "小数扩展转换"d : ISK.fpext,
        "无符号整数到小数转换"d : ISK.uitofp,
        "带符号整数到小数转换"d : ISK.sitofp,
        "小数到无符号整数转换"d : ISK.fptoui,
        "小数到带符号整数转换"d : ISK.fptosi,
        "整数到指针转换"d : ISK.inttoptr,
        "指针到整数转换"d : ISK.ptrtoint,
        "位转换"d : ISK.bitcast,
        "地址空间转换"d : ISK.addrspacecast,
        "选择"d : ISK.select,
        "可变参数_实参"d : ISK.va_arg,
        "着陆场"d : ISK.landingpad,
        "个性"d : ISK.personality,
        "清理"d : ISK.cleanup,
        "捕获"d : ISK.catch_,
        "过滤"d : ISK.filter,
        "返回"d : ISK.ret,
        "跳转"d : ISK.br,
        "假如"d : ISK.switch_,
        "直接跳转"d : ISK.indirectbr,
        "唤出"d : ISK.invoke,
        "重启"d : ISK.resume,
        "不及"d : ISK.unreachable,
        "清理返回"d : ISK.cleanupret,
        "捕获分支"d : ISK.catchswitch,
        "捕获返回"d : ISK.catchret,
        "捕获场"d : ISK.catchpad,
        "清理着陆场"d : ISK.cleanuppad,
        "调用跳转"d : ISK.callbr,
        "分配"d : ISK.alloca,
        "加载"d : ISK.load,
        "储存"d : ISK.store,
        "格栅"d : ISK.fence,
        "原子修改内存按条件"d : ISK.cmpxchg,
        "原子修改内存"d : ISK.atomicrmw,
        "获取元素指针"d : ISK.getelementptr,
        "提取元素"d : ISK.extractelement,
        "插入元素"d : ISK.insertelement,
        "洗牌向量"d : ISK.shufflevector,
        "提取值"d : ISK.extractvalue,
        "插入值"d : ISK.insertvalue,
        "块地址"d : ISK.blockaddress,
        "dso_局部_等效"d : ISK.dso_local_equivalent,
        "冻结"d : ISK.freeze,
        "新鲜的"d : ISK.distinct,
        "用户历史记录"d : ISK.uselistorder,
        "用户历史记录bb"d : ISK.uselistorder_bb,
        "路径"d : ISK.path,
        "哈希"d : ISK.hash,
        "全局值"d : ISK.gv,
        "唯一标识符"d : ISK.guid,
        "名称"d : ISK.name,
        "摘要组"d : ISK.summaries,
        "标志"d : ISK.flags,
        "块数"d : ISK.blockcount,
        "链接模式说明"d : ISK.linkage,
        "可见性"d : ISK.visibility,
        "没有资格导入"d : ISK.notEligibleToImport,
        "存活"d : ISK.live,
        "dso本地"d : ISK.dsoLocal,
        "可以自动隐藏"d : ISK.canAutoHide,
        "函数"d : ISK.function_,
        "学院组"d : ISK.insts,
        "函数标志"d : ISK.funcFlags,
        "不可读的"d : ISK.readNone,
        "只读的"d : ISK.readOnly,
        "不可递归"d : ISK.noRecurse,
        "返回不包含别名"d : ISK.returnDoesNotAlias,
        "绝不内联"d : ISK.noInline,
        "始终内联"d : ISK.alwaysInline,
        "不展开标志"d : ISK.noUnwind,
        "可以抛出"d : ISK.mayThrow,
        "有未知调用"d : ISK.hasUnknownCall,
        "调用组"d : ISK.calls,
        "被调用者"d : ISK.callee,
        "形参组"d : ISK.params,
        "形参"d : ISK.param,
        "热度"d : ISK.hotness,
        "未知"d : ISK.unknown,
        "热的"d : ISK.hot,
        "关键的"d : ISK.critical,
        "相对分支频率"d : ISK.relbf,
        "变量"d : ISK.variable,
        "虚表函数组"d : ISK.vTableFuncs,
        "虚函数"d : ISK.virtFunc,
        "别名组"d : ISK.aliasee,
        "引用组"d : ISK.refs,
        "类型id信息"d : ISK.typeIdInfo,
        "类型测试组"d : ISK.typeTests,
        "类型测试虚调用"d : ISK.typeTestAssumeVCalls,
        "类型检查加载调用"d : ISK.typeCheckedLoadVCalls,
        "类型测试假定常量调用"d : ISK.typeTestAssumeConstVCalls,
        "类型检查加载常量调用"d : ISK.typeCheckedLoadConstVCalls,
        "虚函数Id"d : ISK.vFuncId,
        "偏移集合"d : ISK.offset,
        "实参组"d : ISK.args,
        "类型Id"d : ISK.typeid_,
        "类型id兼容表"d : ISK.typeidCompatibleVTable,
        "摘要"d : ISK.summary,
        "类型测试资源"d : ISK.typeTestRes,
        "种类"d : ISK.kind,
        "不安全"d : ISK.unsat,
        "比特数组"d : ISK.byteArray,
        "内联"d : ISK.inline,
        "单一的"d : ISK.single,
        "全部的"d : ISK.allOnes,
        "M1位宽度大小"d : ISK.sizeM1BitWidth,
        "对齐日志2"d : ISK.alignLog2,
        "M1大小"d : ISK.sizeM1,
        "位掩码"d : ISK.bitMask,
        "内联位组"d : ISK.inlineBits,
        "调用可见性"d : ISK.vcall_visibility,
        "全程序驱动解决方案"d : ISK.wpdResolutions,
        "全程序驱动方案"d : ISK.wpdRes,
        "常规通话"d : ISK.indir,
        "单一实例"d : ISK.singleImpl,
        "使用分支"d : ISK.branchFunnel,
        "单一实例名称"d : ISK.singleImplName,
        "资源按参数"d : ISK.resByArg,
        "按参数"d : ISK.byArg,
        "均匀收益值优化"d : ISK.uniformRetVal,
        "唯一回报值优化"d : ISK.uniqueRetVal,
        "虚常数传播"d : ISK.virtualConstProp,
        "信息"d : ISK.info,
        "字节"d : ISK.byte_,
        "比特"d : ISK.bit,
        "变量标志"d : ISK.varFlags,
        "无值"d : ISK.void_,
        "half"d : ISK.half,
        "hf"d : ISK.half,
        "bfloat"d : ISK.bfloat,
        "bf"d : ISK.bfloat,
        "float"d : ISK.float_,
        "f32"d : ISK.float_,
        "double"d : ISK.double_,
        "f64"d : ISK.double_,
        "x86_fp80"d : ISK.x86_fp80,
        "f80"d : ISK.x86_fp80,
        "fp128"d : ISK.fp128,
        "f128"d : ISK.fp128,
        "ppc_fp128"d : ISK.ppc_fp128,
        "pf128"d : ISK.ppc_fp128,
        "标签"d : ISK.label,
        "元数据"d : ISK.metadata,
        "x86_mmx"d : ISK.x86_mmx,
        "mmx"d : ISK.x86_mmx,
        "x86_amx"d : ISK.x86_amx,
        "amx"d : ISK.x86_amx,
        "令牌"d : ISK.token,
        "指针"d : ISK.ptr,
        "x"d : ISK.x,
        "元素类型"d : ISK.elementtype,
        "禁止内存边界检测"d : ISK.disable_sanitizer_instrumentation
    ];
    _IR令牌文本表 = ··spread!(ISK, dstring)(cast()(._标点表), cast()(._关键字表));
    _IR中文令牌文本表 = ··spread!(ISK, dstring)(cast()(._标点表), cast()(._中文关键字表_));
    组合令牌文本 = ["..."d];
    组合令牌关联数组 = .生成字符表(.组合令牌文本);
    _中英文关键字表 = ··spread!(ISK, dstring)(cast()(._关键字表), cast()(._中文关键字表_));
    关键字词典 = .创建关键字词典(._中英文关键字表);
    标点令牌表 = .创建关键字词典(._标点表);
    关键字文本数组 = .制作关键字文本数组(._IR令牌文本表);
    中文关键字文本数字 = .制作关键字文本数组(._IR中文令牌文本表);
}
简单链表_[dchar] 生成字符表(dstring[] 数组) {
    简单链表_[dchar] ret;
    foreach (dstring s; 数组) {
        if (s !is ··null!(dstring)) {
            dchar ch = (cast()(s[0]));
            if (.具有!(简单链表_, dchar)(ret, ch) is ··null!(简单链表_*)) {
                ret[ch] = new 简单链表_(ch);
            }
            简单链表_ 表 = ret[ch];
            {
                for (int i = 1; i < s.length; ++i) {
                    dchar ch2 = (cast()(s[i]));
                    简单链表_[dchar] 下个 = 表.下个;
                    if (下个 is ··null!(简单链表_[dchar])) {
                        表.下个 = [ch2 : new 简单链表_(ch)];
                    }
                    else {
                        if (.具有!(简单链表_, dchar)(下个, ch2) is ··null!(简单链表_*)) {
                            下个[ch2] = new 简单链表_(ch2);
                        }
                        表 = 下个[ch2];
                    }
                }
            }
        }
    }
    return ret;
}
词典_!(ISK) 创建关键字词典(ISK[dstring] 表) {
    return 创建词典从关联数组!(ISK)(表);
}
ISK 标识符转ISK(dstring id, ISK ISK) {
    if (关键字词典.具有(id)) {
        return 关键字词典.获取(id);
    }
    return ISK;
}
ISK 获取组合标点令牌(dstring id) {
    if (标点令牌表.具有(id)) {
        return 标点令牌表.获取(id);
    }
    return ISK.未知__;
}
dstring[] 制作关键字文本数组(ISK[dstring] 表) {
    dstring[] 结果 = 创建数组!(dstring)();
    结果.length = ISK.数量_;
    foreach (dstring v, ISK i; 表) {
        结果[(cast(size_t)(i))] = v;
    }
    return 结果;
}
dstring 获取ISK关键字文本(long isk, bool 输出中文 = false) {
    if (输出中文) {
        dstring 内容 = 中文关键字文本数字[(cast(size_t)(isk))];
        if (内容 !is ··null!(dstring)) {
            return 内容;
        }
    }
    return 关键字文本数组[(cast(size_t)(isk))];
}
ISK 转换SK为ISK(SK sk) {
    switch (sk) {
        case SK.未知__: {
            return ISK.未知__;
        }
        case SK.文件结尾: {
            return ISK.文件结尾;
        }
        case SK.单行注释: {
            return ISK.单行注释;
        }
        case SK.多行注释: {
            return ISK.多行注释;
        }
        case SK.新行: {
            return ISK.新行;
        }
        case SK.空白: {
            return ISK.空白;
        }
        case SK.指令注释: {
            return ISK.指令注释;
        }
        case SK.冲突标记: {
            return ISK.冲突标记;
        }
        case SK.数字字面量: {
            return ISK.数字字面量;
        }
        case SK.文本字面量: {
            return ISK.文本字面量;
        }
        case SK.左大括号: {
            return ISK.左大括号;
        }
        case SK.右大括号: {
            return ISK.右大括号;
        }
        case SK.左括号: {
            return ISK.左括号;
        }
        case SK.右括号: {
            return ISK.右括号;
        }
        case SK.左方括号: {
            return ISK.左方括号;
        }
        case SK.右方括号: {
            return ISK.右方括号;
        }
        case SK.双引号: {
            return ISK.双引号;
        }
        case SK.单引号: {
            return ISK.单引号;
        }
        case SK.点号: {
            return ISK.点号;
        }
        case SK.分号: {
            return ISK.分号;
        }
        case SK.逗号: {
            return ISK.逗号;
        }
        case SK.左尖括号: {
            return ISK.左尖括号;
        }
        case SK.右尖括号: {
            return ISK.右尖括号;
        }
        case SK.加号: {
            return ISK.加号;
        }
        case SK.减号: {
            return ISK.减号;
        }
        case SK.星号: {
            return ISK.星号;
        }
        case SK.反斜杠: {
            return ISK.反斜杠;
        }
        case SK.除号: {
            return ISK.除号;
        }
        case SK.百分号: {
            return ISK.百分号;
        }
        case SK.且号: {
            return ISK.且号;
        }
        case SK.或号: {
            return ISK.或号;
        }
        case SK.异或号: {
            return ISK.异或号;
        }
        case SK.叹号: {
            return ISK.叹号;
        }
        case SK.波折号: {
            return ISK.波折号;
        }
        case SK.美元: {
            return ISK.美元;
        }
        case SK.问号: {
            return ISK.问号;
        }
        case SK.冒号: {
            return ISK.冒号;
        }
        case SK.艾特: {
            return ISK.艾特;
        }
        case SK.井号: {
            return ISK.井号;
        }
        case SK.反引号: {
            return ISK.反引号;
        }
        case SK.等号: {
            return ISK.等号;
        }
        case SK.标识符: {
            return ISK.标识符;
        }
        case SK.源文件: {
            return ISK.源文件;
        }
        default: {
            return ISK.保留不使用目标;
        }
    }
}
ISK SKs转为KSK(SK[] sks) {
    switch (sks.length) {
        case 1: {
            return .转换SK为ISK(sks[0]);
        }
        case 3: {
            SK sk_0 = sks[0];
            SK sk_1 = sks[1];
            SK sk_2 = sks[2];
            if (sk_0 == SK.点号 && sk_1 == SK.点号 && sk_2 == SK.点号) {
                return ISK.三点号;
            }
        }
        default: break;
    }
    return ISK.未知__;
}
SK 转换ISK为SK(ISK ksk) {
    switch (ksk) {
        case ISK.未知__: {
            return SK.未知__;
        }
        case ISK.文件结尾: {
            return SK.文件结尾;
        }
        case ISK.单行注释: {
            return SK.单行注释;
        }
        case ISK.多行注释: {
            return SK.多行注释;
        }
        case ISK.新行: {
            return SK.新行;
        }
        case ISK.空白: {
            return SK.空白;
        }
        case ISK.指令注释: {
            return SK.指令注释;
        }
        case ISK.冲突标记: {
            return SK.冲突标记;
        }
        case ISK.数字字面量: {
            return SK.数字字面量;
        }
        case ISK.文本字面量: {
            return SK.文本字面量;
        }
        case ISK.左大括号: {
            return SK.左大括号;
        }
        case ISK.右大括号: {
            return SK.右大括号;
        }
        case ISK.左括号: {
            return SK.左括号;
        }
        case ISK.右括号: {
            return SK.右括号;
        }
        case ISK.左方括号: {
            return SK.左方括号;
        }
        case ISK.右方括号: {
            return SK.右方括号;
        }
        case ISK.双引号: {
            return SK.双引号;
        }
        case ISK.单引号: {
            return SK.单引号;
        }
        case ISK.点号: {
            return SK.点号;
        }
        case ISK.分号: {
            return SK.分号;
        }
        case ISK.逗号: {
            return SK.逗号;
        }
        case ISK.左尖括号: {
            return SK.左尖括号;
        }
        case ISK.右尖括号: {
            return SK.右尖括号;
        }
        case ISK.加号: {
            return SK.加号;
        }
        case ISK.减号: {
            return SK.减号;
        }
        case ISK.星号: {
            return SK.星号;
        }
        case ISK.反斜杠: {
            return SK.反斜杠;
        }
        case ISK.除号: {
            return SK.除号;
        }
        case ISK.百分号: {
            return SK.百分号;
        }
        case ISK.且号: {
            return SK.且号;
        }
        case ISK.或号: {
            return SK.或号;
        }
        case ISK.异或号: {
            return SK.异或号;
        }
        case ISK.叹号: {
            return SK.叹号;
        }
        case ISK.波折号: {
            return SK.波折号;
        }
        case ISK.美元: {
            return SK.美元;
        }
        case ISK.问号: {
            return SK.问号;
        }
        case ISK.冒号: {
            return SK.冒号;
        }
        case ISK.艾特: {
            return SK.艾特;
        }
        case ISK.井号: {
            return SK.井号;
        }
        case ISK.反引号: {
            return SK.反引号;
        }
        case ISK.等号: {
            return SK.等号;
        }
        case ISK.保留不使用标识符: {
            return SK.标识符;
        }
        case ISK.保留不使用目标: {
            return SK.目标;
        }
        case ISK.保留不使用源文件: {
            return SK.源文件;
        }
        default: {
            return SK.未知__;
        }
    }
}
SK[] ISK转为SKs(ISK ksk) {
    if (ksk <= ISK.保留不使用目标) {
        return [.转换ISK为SK(ksk)];
    }
    if (ksk >= ISK.标识符 && ksk <= ISK.vscale) {
        return [SK.标识符];
    }
    switch (ksk) {
        case ISK.三点号: {
            return [SK.点号, SK.点号, SK.点号];
        }
        default: break;
    }
    return ··null!(SK[]);
}
